Summary:

• The direct dependency on gopkg.in/tomb.v1 has been removed.
• The codebase has already been migrated away from tomb to native context-based cancellation and a backoff loop (github.com/grafana/dskit/backoff).
• No additional code changes are required to adopt this dependency removal.

Why this is safe:

• All previous usages of tomb.Tomb within the forked tail package have been removed and replaced with context-based control flows.
• The tail logic has been refactored into a smaller, self-contained tailer that polls with backoff using a provided context and no longer relies on the tomb lifecycle.

Key migrations observed in this PR:

• tomb-driven watcher and polling logic removed:
  • internal/component/loki/source/file/internal/tail/watch/* removed
  • internal/component/loki/source/file/internal/tail/tail.go removed (which used tomb.Tomb)
• Replaced with context and backoff:
  • New block polling: internal/component/loki/source/file/internal/tail/block.go
  • New File tailer API using context and dskit/backoff: internal/component/loki/source/file/internal/tail/file.go
  • Windows file handling consolidated under fileext with delete-pending detection

Relevant snippets (before vs after):

• Old (tomb used in tail loop and watcher):

  // tail.go (removed)
  type Tail struct {
      ...
      tomb.Tomb // provides: Done, Kill, Dying
  }
  
  func (tail *Tail) tailFileSync() {
      defer tail.Done()
      defer tail.close()
  
      for {
          ...
          case <-tail.changes.Modified:
          case <-tail.Dying():
              return
          }
      }
  }
  

• New (context + backoff):

  // block.go (new)
  backoff := backoff.New(ctx, backoff.Config{
      MinBackoff: cfg.WatcherConfig.MinPollFrequency,
      MaxBackoff: cfg.WatcherConfig.MaxPollFrequency,
  })
  ...
  for backoff.Ongoing() {
      ...
      backoff.Wait()
  }
  
  // file.go (new)
  ctx, cancel := context.WithCancel(context.Background())
  ...
  func (f *File) Next() (*Line, error) {
      if f.ctx.Err() != nil {
          return nil, f.ctx.Err()
      }
      ...
      if errors.Is(err, io.EOF) {
          if err := f.wait(text != ""); err != nil {
              return nil, err
          }
          goto read
      }
  }
  
  func (f *File) Stop() error {
      f.cancel()
      f.mu.Lock()
      defer f.mu.Unlock()
      return f.file.Close()
  }
  

If you need to remove tomb usage elsewhere in your codebase, here’s a concise migration pattern:

• Replace a tomb-driven goroutine lifecycle with context cancellation.
• Replace tomb.Dying() checks with <-ctx.Done() or checking ctx.Err().
• Return context.Canceled when stopping to mirror previous stop semantics.

Example migration diff:

- type Worker struct {
-   Tomb tomb.Tomb
- }
+ type Worker struct {
+   ctx    context.Context
+   cancel context.CancelFunc
+ }

- func (w *Worker) Start() {
-   w.Tomb.Go(func() error {
-     for {
-       select {
-       case <-w.Tomb.Dying():
-         return nil
-       default:
-         // work
-       }
-     }
-   })
- }
+ func (w *Worker) Start() {
+   w.ctx, w.cancel = context.WithCancel(context.Background())
+   go func() {
+     defer func() { /* cleanup */ }()
+     for {
+       select {
+       case <-w.ctx.Done():
+         return
+       default:
+         // work
+       }
+     }
+   }()
+ }

- func (w *Worker) Stop() error {
-   w.Tomb.Kill(nil)
-   return w.Tomb.Wait()
- }
+ func (w *Worker) Stop() error {
+   if w.cancel != nil {
+     w.cancel()
+   }
+   return nil
+ }

No changes to imports are necessary beyond removing gopkg.in/tomb.v1 (imports that still reference tomb would fail to compile, but the current codebase no longer contains such imports).